Padrões Proxy de Módulos JavaScript: Dominando o Controle de Acesso

            var myModule = (function() {
  // Variáveis e funções privadas
  var privateCounter = 0;

  function privateIncrement() {
    privateCounter++;
    console.log('Contador privado:', privateCounter);
  }

  // Métodos e propriedades acessíveis publicamente
  function publicIncrement() {
    privateIncrement();
  }

  function getCounter() {
    return privateCounter;
  }

  // Revelando a interface pública
  return {
    increment: publicIncrement,
    count: getCounter
  };
})();

// Uso:
myModule.increment(); // Logs: Contador privado: 1
console.log(myModule.count()); // Logs: 1
// console.log(myModule.privateCounter); // undefined (privado)
// myModule.privateIncrement(); // TypeError: myModule.privateIncrement is not a function (privado)

            

              
                Copy
              
            
          

            // Imagine um subsistema complexo para autenticação de usuário
var AuthSubsystem = {
  login: function(username, password) {
    console.log(`Autenticando usuário: ${username}`);
    // ... lógica complexa de autenticação ...
    return true;
  },
  logout: function(userId) {
    console.log(`Saindo do usuário: ${userId}`);
    // ... lógica complexa de logout ...
    return true;
  },
  resetPassword: function(email) {
    console.log(`Redefinindo senha para: ${email}`);
    // ... lógica de redefinição de senha ...
    return true;
  }
};

// O módulo Fachada
var AuthFacade = (function() {
  function authenticateUser(username, password) {
    // Validação básica antes de chamar o subsistema
    if (!username || !password) {
      console.error('Nome de usuário e senha são obrigatórios.');
      return false;
    }
    return AuthSubsystem.login(username, password);
  }

  function endSession(userId) {
    if (!userId) {
      console.error('ID do usuário é obrigatório para encerrar a sessão.');
      return false;
    }
    return AuthSubsystem.logout(userId);
  }

  // Nós escolhemos NÃO expor resetPassword diretamente via fachada para este exemplo
  // Talvez exija um contexto de segurança diferente.

  return {
    login: authenticateUser,
    logout: endSession
  };
})();

// Uso:
AuthFacade.login('globalUser', 'securePass123'); // Autenticando usuário: globalUser
AuthFacade.logout(12345);
// AuthFacade.resetPassword('test@example.com'); // TypeError: AuthFacade.resetPassword is not a function

            

              
                Copy
              
            
          

            // Módulo Original (poderia estar usando o Padrão Módulo Revelador internamente)
var ConfigModule = (function() {
  var config = {
    apiKey: 'super-secret-api-key-12345',
    databaseUrl: 'mongodb://localhost:27017/mydb',
    debugMode: false,
    featureFlags: ['newUI', 'betaFeature']
  };

  function toggleDebugMode() {
    config.debugMode = !config.debugMode;
    console.log(`O modo de depuração agora é: ${config.debugMode}`);
  }

  function addFeatureFlag(flag) {
    if (!config.featureFlags.includes(flag)) {
      config.featureFlags.push(flag);
      console.log(`Adicionado sinalizador de recurso: ${flag}`);
    }
  }

  return {
    settings: config,
    toggleDebug: toggleDebugMode,
    addFlag: addFeatureFlag
  };
})();

// --- Agora, vamos aplicar um Proxy para controle de acesso ---

function createConfigProxy(module, userRole) {
  const protectedProperties = ['apiKey', 'databaseUrl'];

  const handler = {
    get: function(target, property) {
      // Se a propriedade estiver protegida e o usuário não for um administrador
      if (protectedProperties.includes(property) && userRole !== 'admin') {
        console.warn(`Acesso negado: Não é possível ler a propriedade protegida '${property}' como um ${userRole}.`);
        return undefined; // Ou lance um erro
      }
      // Se a propriedade for uma função, certifique-se de que ela seja chamada no contexto correto
      if (typeof target[property] === 'function') {
        return target[property].bind(target); // Vincular para garantir que 'this' esteja correto
      }
      return target[property];
    },
    set: function(target, property, value) {
      // Impedir a modificação de propriedades protegidas por não administradores
      if (protectedProperties.includes(property) && userRole !== 'admin') {
        console.warn(`Acesso negado: Não é possível escrever na propriedade protegida '${property}' como um ${userRole}.`);
        return false; // Indicar falha
      }
      // Impedir a adição de propriedades que não fazem parte do esquema original (opcional)
      if (!target.hasOwnProperty(property)) {
         console.warn(`Acesso negado: Não é possível adicionar a nova propriedade '${property}'.`);
         return false;
      }
      target[property] = value;
      console.log(`Propriedade '${property}' definida como:`, value);
      return true;
    }
  };

  // Nós proxyamos o objeto 'settings' dentro do módulo
  const proxiedConfig = new Proxy(module.settings, handler);

  // Retorne um novo objeto que exponha as configurações proxyadas e os métodos permitidos
  return {
    getSetting: function(key) { return proxiedConfig[key]; }, // Use getSetting para acesso de leitura explícito
    setSetting: function(key, val) { proxiedConfig[key] = val; }, // Use setSetting para acesso de escrita explícito
    toggleDebug: module.toggleDebug,
    addFlag: module.addFlag
  };
}

// --- Uso com diferentes funções ---

const regularUserConfig = createConfigProxy(ConfigModule, 'user');
const adminUserConfig = createConfigProxy(ConfigModule, 'admin');

console.log('--- Acesso do Usuário Regular ---');
console.log('Chave da API:', regularUserConfig.getSetting('apiKey')); // Logs warning, returns undefined
console.log('Modo de Depuração:', regularUserConfig.getSetting('debugMode')); // Logs: false
regularUserConfig.toggleDebug(); // Logs: O modo de depuração agora é: true
console.log('Modo de Depuração após alternância:', regularUserConfig.getSetting('debugMode')); // Logs: true
regularUserConfig.addFlag('newFeature'); // Adiciona flag

console.log('\n--- Acesso do Usuário Administrador ---');
console.log('Chave da API:', adminUserConfig.getSetting('apiKey')); // Logs: super-secret-api-key-12345
adminUserConfig.setSetting('apiKey', 'new-admin-key-98765'); // Logs: Propriedade 'apiKey' definida como: new-admin-key-98765
console.log('Chave da API atualizada:', adminUserConfig.getSetting('apiKey')); // Logs: new-admin-key-98765
adminUserConfig.setSetting('databaseUrl', 'sqlite://localhost'); // Permitido

// Tentando adicionar uma nova propriedade como um usuário regular
// regularUserConfig.setSetting('newProp', 'value'); // Logs warning, fails silently

            

              
                Copy
              
            
          

            // Um módulo simulando transações financeiras
var TransactionModule = (function() {
  var balance = 1000;
  var transactionLimit = 500;
  var historicalTransactions = [];

  function processDeposit(amount) {
    if (amount <= 0) {
      console.error('O valor do depósito deve ser positivo.');
      return false;
    }
    balance += amount;
    historicalTransactions.push({ type: 'deposit', amount: amount });
    console.log(`Depósito bem-sucedido. Novo saldo: ${balance}`);
    return true;
  }

  function processWithdrawal(amount) {
    if (amount <= 0) {
      console.error('O valor da retirada deve ser positivo.');
      return false;
    }
    if (amount > balance) {
      console.error('Fundos insuficientes.');
      return false;
    }
    if (amount > transactionLimit) {
      console.error(`O valor da retirada excede o limite de transação de ${transactionLimit}.`);
      return false;
    }
    balance -= amount;
    historicalTransactions.push({ type: 'withdrawal', amount: amount });
    console.log(`Retirada bem-sucedida. Novo saldo: ${balance}`);
    return true;
  }

  function getBalance() {
    return balance;
  }

  function getTransactionHistory() {
    // Pode querer retornar uma cópia para evitar modificação externa
    return [...historicalTransactions];
  }

  return {
    deposit: processDeposit,
    withdraw: processWithdrawal,
    balance: getBalance,
    history: getTransactionHistory
  };
})();

// --- Proxy para controlar transações com base na sessão do usuário ---

function createTransactionProxy(module, isAuthenticated) {
  const handler = {
    // Interceptando chamadas de função
    get: function(target, property, receiver) {
      const originalMethod = target[property];

      if (typeof originalMethod === 'function') {
        // Se for um método de transação, envolva-o com a verificação de autenticação
        if (property === 'deposit' || property === 'withdraw') {
          return function(...args) {
            if (!isAuthenticated) {
              console.warn(`Acesso negado: Usuário não autenticado para executar '${property}'.`);
              return false;
            }
            // Passe os argumentos para o método original
            return originalMethod.apply(this, args);
          };
        }
        // Para outros métodos como getBalance, history, permita o acesso se eles existirem
        return originalMethod.bind(this);
      }
      // Para propriedades como 'balance', 'history', retorne-as diretamente
      return originalMethod;
    }
    // Poderíamos também implementar 'set' para propriedades como transactionLimit, se necessário
  };

  return new Proxy(module, handler);
}

// --- Uso ---

console.log('\n--- Módulo de Transação com Proxy ---');

const unauthenticatedTransactions = createTransactionProxy(TransactionModule, false);
const authenticatedTransactions = createTransactionProxy(TransactionModule, true);

console.log('Saldo Inicial:', unauthenticatedTransactions.balance()); // 1000

console.log('\n--- Realizando Transações (Não Autenticado) ---');
unauthenticatedTransactions.deposit(200);
// Logs warning: Acesso negado: Usuário não autenticado para executar 'deposit'. Retorna false.
unauthenticatedTransactions.withdraw(100);
// Logs warning: Acesso negado: Usuário não autenticado para executar 'withdraw'. Retorna false.
console.log('Saldo após tentativas de transações:', unauthenticatedTransactions.balance()); // 1000

console.log('\n--- Realizando Transações (Autenticado) ---');
authenticatedTransactions.deposit(300);
// Logs: Depósito bem-sucedido. Novo saldo: 1300
authenticatedTransactions.withdraw(150);
// Logs: Retirada bem-sucedida. Novo saldo: 1150
console.log('Saldo após transações bem-sucedidas:', authenticatedTransactions.balance()); // 1150

console.log('Histórico de Transações:', authenticatedTransactions.history());
// Logs: [ { type: 'deposit', amount: 300 }, { type: 'withdrawal', amount: 150 } ]

// Tentando retirada excedendo o limite
authenticatedTransactions.withdraw(600);
// Logs: O valor da retirada excede o limite de transação de 500. Retorna false.

            

              
                Copy
              
            
          

            // Exemplo: Combinando o Padrão Módulo Revelador com um Proxy para controle de acesso

function createSecureDataAccessModule(initialData, userPermissions) {
  // Use o Padrão Módulo Revelador para estrutura interna e encapsulamento básico
  var privateData = initialData;
  var permissions = userPermissions;

  function readData(key) {
    if (permissions.read.includes(key)) {
      return privateData[key];
    }
    console.warn(`Acesso de leitura negado para a chave: ${key}`);
    return undefined;
  }

  function writeData(key, value) {
    if (permissions.write.includes(key)) {
      privateData[key] = value;
      console.log(`Gravado com sucesso na chave: ${key}`);
      return true;
    }
    console.warn(`Acesso de escrita negado para a chave: ${key}`);
    return false;
  }

  function deleteData(key) {
    if (permissions.delete.includes(key)) {
      delete privateData[key];
      console.log(`Chave excluída com sucesso: ${key}`);
      return true;
    }
    console.warn(`Acesso de exclusão negado para a chave: ${key}`);
    return false;
  }

  // Retorne a API pública
  return {
    getData: readData,
    setData: writeData,
    deleteData: deleteData,
    listKeys: function() { return Object.keys(privateData); }
  };
}

// Agora, envolva a API pública deste módulo com um Proxy para controle ainda mais refinado ou ajustes dinâmicos

function createProxyWithExtraChecks(module, role) {
  const handler = {
    get: function(target, property) {
      // Verificação adicional: talvez 'listKeys' seja permitido apenas para funções de administrador
      if (property === 'listKeys' && role !== 'admin') {
        console.warn('A operação listKeys é restrita à função de administrador.');
        return () => undefined; // Retorna uma função dummy
      }
      // Delegue aos métodos do módulo original
      return target[property];
    },
    set: function(target, property, value) {
      // Certifique-se de que estamos definindo apenas via setData, não diretamente no objeto retornado
      if (property === 'setData') {
        // Esta armadilha intercepta tentativas de atribuir a target.setData em si
        console.warn('Não é possível reatribuir diretamente o método setData.');
        return false;
      }
      // Para outras propriedades (como os próprios métodos), queremos evitar a reatribuição
      if (typeof target[property] === 'function') {
        console.warn(`Tentativa de reatribuir o método '${property}'.`);
        return false;
      }
      return target[property] = value;
    }
  };

  return new Proxy(module, handler);
}


// --- Uso ---

const userPermissions = {
  read: ['username', 'email'],
  write: ['email'],
  delete: []
};

const userDataModule = createSecureDataAccessModule({
  username: 'globalUser',
  email: 'user@example.com',
  preferences: { theme: 'dark' }
}, userPermissions);

const proxiedUserData = createProxyWithExtraChecks(userDataModule, 'user');
const proxiedAdminData = createProxyWithExtraChecks(userDataModule, 'admin'); // Assumindo que o administrador tem acesso total implicitamente por permissões superiores passadas em um cenário real

console.log('\n--- Uso do Padrão Combinado ---');

console.log('Dados do Usuário:', proxiedUserData.getData('username')); // globalUser
console.log('Preferências do Usuário:', proxiedUserData.getData('preferences')); // undefined (não nas permissões de leitura)

proxiedUserData.setData('email', 'new.email@example.com'); // Permitido
proxiedUserData.setData('username', 'anotherUser'); // Negado

console.log('E-mail do Usuário:', proxiedUserData.getData('email')); // new.email@example.com

console.log('Chaves (Usuário):', proxiedUserData.listKeys()); // Logs warning: A operação listKeys é restrita à função de administrador. Retorna undefined.

console.log('Chaves (Admin):', proxiedAdminData.listKeys()); // [ 'username', 'email', 'preferences' ]

// Tentativa de reatribuir um método
// proxiedUserData.getData = function() { return 'hacked'; }; // Logs warning, fails

            

              
                Copy